home *** CD-ROM | disk | FTP | other *** search
/ Die Ultimative Software-P…i Collection 1996 & 1997 / Die Ultimative Software-Pakete CD-ROM fur Atari Collection 1996 & 1997.iso / w / wissensc / funktion / quelle / draw.pas next >
Encoding:
Pascal/Delphi Source File  |  1996-09-18  |  10.5 KB  |  342 lines
  1. {-----------------------------------------------------------------------------}
  2. { Dieses Modul enthält alle Routinen, die zur Darstellung des Achsenkreuzes   }
  3. { und zum Zeichnen der Funktion nötig sind.                                   }
  4. {                                                                             }
  5. { (c) WURMSOFTWARE im Mai 1987                                                }
  6. {-----------------------------------------------------------------------------}
  7.  
  8. {=======================   Do_x_Koordinaten  =================================}
  9.  
  10.      { Berechnung der Abbildungsfaktoren aus den eingegebenen Parametern }
  11.  
  12.  
  13. FUNCTION  Do_x_Koordinaten (VAR draw     : draw_type ;
  14.                             VAR fkt_wert : fkt_wert_type) : integer ;
  15.  
  16.  VAR  flag               : boolean ;
  17.       i, fehler, zusatz  : integer ;
  18.  
  19.  BEGIN
  20.   fehler := 0 ;
  21.  
  22.   {-- Holen der aktuellen Werte --}
  23.  
  24.   flag := Zahl_Einlesen (werte_zei, zxmin,   draw.x_min) ;
  25.   flag := Zahl_Einlesen (werte_zei, zxmax,   draw.x_max) ;
  26.  
  27.   {-- Auswerten der x_Werte --}
  28.  
  29.   IF draw.x_min >= draw.x_max THEN fehler := 1
  30.    ELSE
  31.     BEGIN  {-- also bei gültigen x-Grenzen !! --}
  32.  
  33.      IF draw.x_log THEN  {-- bei logarithmischer x-Einteilung --}
  34.       BEGIN
  35.        IF draw.x_min <= 0 THEN fehler := 2  {-- LOG-Einteilung > 0 --}
  36.         ELSE
  37.          BEGIN
  38.           IF draw.x_min < 1  THEN zusatz := -1
  39.           ELSE                    zusatz :=  1 ;
  40.           draw.max_pot_x := TRUNC (LOG (draw.x_max) + 0.1) ;
  41.           draw.min_pot_x := TRUNC (LOG (draw.x_min) + zusatz) ;
  42.  
  43.           draw.x_max     := NPwrOfTen (draw.max_pot_x + 1) ;
  44.           draw.x_min     := NPwrOfTen (draw.min_pot_x) ;
  45.  
  46.           draw.dx        := 600 / ABS (LOG (draw.x_max) - LOG (draw.x_min)) ;
  47.           draw.null_x    := TRUNC (ABS (draw.min_pot_x * draw.dx)) ;
  48.          END ;
  49.       END
  50.      ELSE
  51.       BEGIN
  52.        IF draw.x_min > 0 THEN draw.x_min := 0 ;
  53.        draw.dx     := 600 / ABS (draw.x_max - draw.x_min) ;
  54.        draw.null_x := TRUNC (ABS (draw.x_min * draw.dx)) ;
  55.       END ;
  56.     END ;
  57.   Do_x_Koordinaten := fehler ;
  58.  END ;
  59.  
  60.  
  61. {=======================   Do_y_Koordinaten  =================================}
  62.  
  63.      { Berechnung der Abbildungsfaktoren aus den eingegebenen Parametern }
  64.  
  65.  
  66. FUNCTION  Do_y_Koordinaten (VAR draw     : draw_type ;
  67.                             VAR fkt_wert : fkt_wert_type) : integer ;
  68.  
  69.  VAR  flag               : boolean ;
  70.       i, fehler, zusatz  : integer ;
  71.  
  72.  BEGIN
  73.   fehler := 0 ;
  74.  
  75.   {-- Holen der aktuellen Werte --}
  76.  
  77.   flag := Zahl_Einlesen (werte_zei, zymin,   draw.y_min) ;
  78.   flag := Zahl_Einlesen (werte_zei, zymax,   draw.y_max) ;
  79.  
  80.   {-- Auswerten der y_Werte --}
  81.  
  82.   IF draw.y_min >= draw.y_max THEN fehler := 3
  83.    ELSE
  84.     BEGIN  {-- also bei gültigen y-Grenzen !! --}
  85.  
  86.      IF draw.auto THEN  {-- automatische y-Skalierung --}
  87.       BEGIN
  88.  
  89.        IF draw.y_log THEN
  90.         BEGIN
  91.          IF fkt_wert[1] <= 0 THEN draw.y_min := 1
  92.          ELSE                     draw.y_min := fkt_wert[1] ;
  93.         END
  94.        ELSE
  95.         draw.y_min := fkt_wert[1] ;
  96.  
  97.        draw.y_max := fkt_wert[1] ;
  98.        FOR i := 2 TO 600 DO
  99.         BEGIN
  100.  
  101.          IF NOT draw.y_log THEN
  102.           IF fkt_wert[i] < draw.y_min THEN draw.y_min := fkt_wert[i] ;
  103.          IF draw.y_log THEN
  104.           IF (fkt_wert[i] < draw.y_min) AND (fkt_wert[i] > 0) THEN
  105.            draw.y_min := fkt_wert[i] ;
  106.  
  107.          IF fkt_wert[i] > draw.y_max THEN draw.y_max := fkt_wert[i] ;
  108.         END ;
  109.        draw.y_min := draw.y_min + 0.1 * draw.y_min ;
  110.        draw.y_max := draw.y_max + 0.1 * draw.y_max ;
  111.       END ;
  112.  
  113.      IF draw.y_log THEN  {-- bei logarithmischer y-Einteilung --}
  114.       BEGIN
  115.        IF draw.y_min <= 0 THEN fehler := 4  {-- LOG-Einteilung > 0 --}
  116.         ELSE
  117.          BEGIN
  118.           IF draw.y_min < 1  THEN zusatz := -1
  119.           ELSE                    zusatz :=  1 ;
  120.           draw.max_pot_y := TRUNC (LOG (draw.y_max) + 0.1) ;
  121.           draw.min_pot_y := TRUNC (LOG (draw.y_min) + zusatz) ;
  122.  
  123.           draw.y_max     := NPwrOfTen (draw.max_pot_y + 1) ;
  124.           draw.y_min     := NPwrOfTen (draw.min_pot_y) ;
  125.  
  126.           draw.dy        := 400 / ABS (LOG (draw.y_max) - LOG (draw.y_min)) ;
  127.           draw.null_y    := TRUNC (ABS (draw.min_pot_y * draw.dy)) ;
  128.          END ;
  129.       END
  130.      ELSE
  131.       BEGIN
  132.        IF draw.y_min > 0 THEN draw.y_min := 0 ;
  133.        draw.dy     := 400 / ABS (draw.y_max - draw.y_min) ;
  134.        draw.null_y := TRUNC (ABS (draw.y_min * draw.dy)) ;
  135.       END ;
  136.     END ;
  137.   Do_y_Koordinaten := fehler ;
  138.  END ;
  139.  
  140.  
  141. {======================  Do_Kreuz_Zeichnen  ==================================}
  142.  
  143.         { Zeichnet das Koordinatenkreuz gem. Angaben des Users }
  144.  
  145.  
  146. FUNCTION  Do_Kreuz_Zeichnen (VAR draw : draw_type) : integer ;
  147.  
  148.  VAR fehler                 : integer ;
  149.      flag                   : boolean ;
  150.  
  151.  {----- Achse_lin_x : Zeichnet x-Achse (linear) ------------------------------}
  152.  
  153.  PROCEDURE Achse_lin_x ;
  154.  
  155.   VAR plot_x        : integer ;
  156.       strich        : real ;
  157.  
  158.   BEGIN
  159.    IF draw.achsen_art <> ohne THEN
  160.     BEGIN
  161.      IF (draw.x_max - draw.x_min) / draw.x_skala > 300 THEN fehler := 11
  162.      ELSE
  163.       BEGIN
  164.        strich := TRUNC (draw.x_min / draw.x_skala) * draw.x_skala ;
  165.        WHILE (strich <= draw.x_max) OR (plot_x + strich * draw.dx < 600) DO
  166.         BEGIN
  167.          plot_x := draw.null_x + TRUNC (strich * draw.dx) ;
  168.          IF draw.achsen_art = netz THEN
  169.           line (plot_x+20, 0, plot_x+20, 399, 1, 0, 0, 0, $8888, 1) ;
  170.          line (plot_x+20, 399-draw.null_y-1, plot_x+20, 399-draw.null_y-4,
  171.                1, 0, 0, 0, -1,0) ;
  172.          strich := strich + draw.x_skala ;
  173.         END ;
  174.       END ;
  175.     END ;
  176.    line (20, 399 - draw.null_y, 620, 399 - draw.null_y, 1, 0, 0, 0, -1, 0) ;
  177.   END ;
  178.  
  179.  
  180.  {----- Achse_lin_y : Zeichnet y-Achse (linear) ------------------------------}
  181.  
  182.  PROCEDURE Achse_lin_y ;
  183.  
  184.   VAR plot_y        : integer ;
  185.       strich        : real ;
  186.  
  187.   BEGIN
  188.    IF draw.achsen_art <> ohne THEN
  189.     BEGIN
  190.      IF (draw.y_max - draw.y_min) / draw.y_skala > 200 THEN fehler := 12
  191.      ELSE
  192.       BEGIN
  193.        strich := TRUNC (draw.y_min / draw.y_skala) * draw.y_skala ;
  194.        WHILE (strich <= draw.y_max) OR (plot_y + strich * draw.dy < 400) DO
  195.         BEGIN
  196.          plot_y := draw.null_y + TRUNC (strich * draw.dy) ;
  197.          IF draw.achsen_art = netz THEN
  198.           line (20, 399-plot_y, 620, 399-plot_y, 1, 0, 0, 0, $8888, 1) ;
  199.          line (draw.null_x+21, 399-plot_y, draw.null_x+24, 399-plot_y,
  200.              1, 0, 0, 0, -1, 0) ;
  201.          strich := strich + draw.y_skala ;
  202.         END ;
  203.       END ;
  204.     END ;
  205.    line (draw.null_x+20, 0, draw.null_x+20, 399, 1, 0, 0, 0, -1, 0) ;
  206.   END ;
  207.  
  208.  
  209.  {----- Achse_log_x : Zeichnet x-Achse (logarith.) ---------------------------}
  210.  
  211.  PROCEDURE Achse_log_x ;
  212.  
  213.   VAR i, j, plot_x    : integer ;
  214.       strich          : real ;
  215.  
  216.   BEGIN
  217.    FOR j := draw.min_pot_x TO draw.max_pot_x DO
  218.     BEGIN
  219.      FOR i := 1 TO 9 DO
  220.       BEGIN
  221.        strich := LOG (i * NPwrOfTen(j)) ;
  222.        plot_x := draw.null_x + TRUNC (strich * draw.dx) ;
  223.        IF draw.achsen_art = netz THEN
  224.         line (plot_x+20, 0, plot_x+20, 399, 1, 0, 0, 0, $8888, 1) ;
  225.        line (plot_x+20, 399-draw.null_y-1, plot_x+20, 399-draw.null_y-4,
  226.              1, 0, 0, 0, -1,0) ;
  227.       END ;
  228.     END ;
  229.    line (20, 399 - draw.null_y, 620, 399 - draw.null_y, 1, 0, 0, 0, -1, 0) ;
  230.   END ;
  231.  
  232.  
  233. {----- Achse_log_y : Zeichnet y-Achse (logarith.) ---------------------------}
  234.  
  235.  PROCEDURE Achse_log_y ;
  236.  
  237.   VAR i, j, plot_y     : integer ;
  238.       strich           : real ;
  239.  
  240.   BEGIN
  241.    FOR j := draw.min_pot_y TO draw.max_pot_y DO
  242.     BEGIN
  243.      FOR i := 1 TO 9 DO
  244.       BEGIN
  245.        strich := LOG (i * NPwrOfTen(j)) ;
  246.        plot_y := draw.null_y + TRUNC (strich * draw.dy) ;
  247.        IF draw.achsen_art = netz THEN
  248.         line (20, 399 - plot_y, 620, 399 - plot_y, 1, 0, 0, 0, $8888, 1) ;
  249.        line (draw.null_x+21, 399-plot_y, draw.null_x+24, 399-plot_y,
  250.              1, 0, 0, 0, -1, 0) ;
  251.       END ;
  252.     END ;
  253.    line (draw.null_x+20, 0, draw.null_x+20, 399, 1, 0, 0, 0, -1, 0) ;
  254.   END ;
  255.  
  256.  
  257. {---------------------------- Procedure selbst -------------------------------}
  258.  
  259. BEGIN
  260.  fehler := 0 ;
  261.  flag := Zahl_Einlesen (werte_zei, wskalax, draw.x_skala) ;
  262.  flag := Zahl_Einlesen (werte_zei, wskalay, draw.y_skala) ;
  263.  IF (draw.x_skala = 0) OR (draw.y_skala = 0) THEN fehler := 13
  264.  ELSE
  265.   BEGIN
  266.    IF draw.x_log THEN Achse_log_x
  267.    ELSE               Achse_lin_x ;
  268.    IF draw.y_log THEN Achse_log_y
  269.    ELSE               Achse_lin_y ;
  270.   END ;
  271.  IF fehler <> 0 THEN button := Do_Alert (warn[fehler], 1) ;
  272.  Do_Kreuz_Zeichnen := 0 ;
  273. END ;
  274.  
  275.  
  276. {==================== Do_Draw_Funktion =======================================}
  277.  
  278.       { Zeichnet die berechneten Funktionswerte in den Graphen ein }
  279.  
  280.  
  281. PROCEDURE Do_Draw_Funktion (VAR draw       : draw_type ;
  282.                             VAR fkt_wert   : fkt_wert_type ;
  283.                                 error_feld : error_feld_type ;
  284.                                 step       : integer ) ;
  285.  
  286.  VAR i, plot_x, plot_y,
  287.      help_x, help_y, fehler                : integer ;
  288.  
  289.  BEGIN
  290.   fehler := Do_Kreuz_Zeichnen (draw) ;
  291.   IF fehler <> 0 THEN
  292.    button := Do_Alert (warn[fehler], 1)
  293.   ELSE
  294.    BEGIN
  295.     i := 1 ;
  296.     WHILE i <= 600 DO
  297.      BEGIN
  298.       plot_x := i ;
  299.       IF draw.y_log THEN
  300.        BEGIN
  301.         IF (fkt_wert[i] > 0) THEN
  302.          BEGIN
  303.           IF ((LOG(fkt_wert[i]) * draw.dy) + draw.null_y) < 400 THEN
  304.            plot_y := TRUNC (LOG (fkt_wert[i]) * draw.dy) + draw.null_y
  305.           ELSE
  306.            plot_y := 399 ;
  307.          END
  308.         ELSE
  309.          plot_y := 0 ;
  310.        END
  311.       ELSE
  312.        BEGIN
  313.         IF (draw.null_y + fkt_wert[i] * draw.dy) < 400 THEN
  314.          plot_y := draw.null_y + TRUNC (fkt_wert[i] * draw.dy)
  315.         ELSE
  316.          plot_y := 399
  317.        END ;
  318.  
  319.       IF plot_y < 0   THEN plot_y := 0 ;
  320.  
  321.       IF (i > step) THEN
  322.        BEGIN
  323.         IF (error_feld[i] = 0) AND (error_feld[i-step] = 0) AND draw.verb THEN
  324.          line (help_x + 20, 399 - help_y, plot_x + 20, 399 - plot_y,
  325.                1, 0, 0, 0, -1, 0)
  326.         ELSE
  327.          line (plot_x + 20, 399 - plot_y, plot_x + 20, 399 - plot_y,
  328.                1, 0, 0, 0, -1, 0)
  329.        END
  330.       ELSE
  331.        line (plot_x + 20, 399 - plot_y, plot_x + 20, 399 - plot_y,
  332.              1, 0, 0, 0, -1, 0) ;
  333.  
  334.       help_x := plot_x ; help_y := plot_y ;
  335.       i := i + step ;
  336.      END ;
  337.    END ;
  338.   Do_Merken ;
  339.  END ;
  340.  
  341.  
  342.